package com.woohua.thread.pool;

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

/***
 * @title ScheduledThreadDemo
 * @description: 按计划执行任务线程池demo
 * @author woo hua
 * @version 1.0.0
 * @create 2023/3/17 16:50
 **/
public class ScheduledThreadDemo {

    public static long fixedRateInterval = 0;
    public static long lastFixedRateRunTime = System.nanoTime();

    public static long withFixedInterval = 0;
    public static long lastWithFixedRunTime = System.nanoTime();

    public static void main(String[] args) {
        ScheduledExecutorService executorService = Executors.newScheduledThreadPool(3);

        // 1秒后执行，只执行1次
        executorService.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + " made rice.");
            }
        }, 1, TimeUnit.SECONDS);

        // 1 秒后开始执行，每间隔3秒执行一次，这个间隔时间是从 前一个任务 【执行开始时间】 算起
        lastFixedRateRunTime = System.nanoTime();
        executorService.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                long runTime = System.nanoTime();
                fixedRateInterval = runTime - lastFixedRateRunTime;
                lastFixedRateRunTime = runTime;

                // 模拟任务执行
                sleep(2); // 这个休眠时间不影响下次执行间隔时间的计算
                /**
                 * 1、当任务耗时小于3秒，任务间隔时间为：3秒
                 * 2、当任务耗时大于3秒，任务间隔时间为：任务的执行耗时
                 */
                System.out.println(Thread.currentThread().getName() + " made dish. Interval: " + fixedRateInterval);
            }
        }, 1, 3, TimeUnit.SECONDS);


        // 2 秒后开始执行，每间隔3秒执行一次，这个间隔时间是从 前一个任务 【执行结束时间】 算起
        lastWithFixedRunTime = System.nanoTime();
        executorService.scheduleWithFixedDelay(new Runnable() {
            @Override
            public void run() {
                long runTime = System.nanoTime();
                withFixedInterval = runTime - lastWithFixedRunTime;
                lastWithFixedRunTime = runTime;

                // 模拟任务执行
                sleep(2);   // 这个休眠时间影响下次执行间隔时间的计算，
                /**
                 * 执行间隔是： 任务的执行耗时 + 配置的间隔耗时
                 */
                System.out.println(Thread.currentThread().getName() + " clean up table. Interval: " + withFixedInterval);
            }
        }, 2, 3, TimeUnit.SECONDS);
    }

    private static void sleep(int seconds) {
        try {
            TimeUnit.SECONDS.sleep(seconds);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}
